home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / CPP / WFC010.ZIP / SRC / CRAS.CPP < prev    next >
C/C++ Source or Header  |  1995-12-07  |  19KB  |  773 lines
  1. #include <wfc.h>
  2. #pragma hdrstop
  3.  
  4. /*
  5. ** Author: Samuel R. Blackburn
  6. ** CI$: 76300,326
  7. ** Internet: sammy@sed.csc.com
  8. **
  9. ** You can use it any way you like as long as you don't try to sell it.
  10. **
  11. ** Any attempt to sell WFC in source code form must have the permission
  12. ** of the original author. You can produce commercial executables with
  13. ** WFC but you can't sell WFC.
  14. **
  15. ** Copyright, 1995, Samuel R. Blackburn
  16. **
  17. ** $Workfile: $
  18. ** $Revision: $
  19. ** $Modtime: $
  20. */
  21.  
  22. #if defined( _DEBUG )
  23. #undef THIS_FILE
  24. static char BASED_CODE THIS_FILE[] = __FILE__;
  25. #define new DEBUG_NEW
  26. #endif
  27.  
  28. /*
  29. ** CRASAuthenticationMessageBlock
  30. */
  31.  
  32. CRemoteAccessServiceAuthenticationMessageBlock::CRemoteAccessServiceAuthenticationMessageBlock()
  33. {
  34.    m_Initialize();
  35. }
  36.  
  37. CRemoteAccessServiceAuthenticationMessageBlock::CRemoteAccessServiceAuthenticationMessageBlock( const RASAMB *source )
  38. {
  39.    m_Initialize();
  40.    Copy( source );
  41. }
  42.  
  43. CRemoteAccessServiceAuthenticationMessageBlock::CRemoteAccessServiceAuthenticationMessageBlock( const CRemoteAccessServiceAuthenticationMessageBlock& source )
  44. {
  45.    m_Initialize();
  46.    Copy( source );
  47. }
  48.  
  49. CRemoteAccessServiceAuthenticationMessageBlock::~CRemoteAccessServiceAuthenticationMessageBlock()
  50. {
  51.    m_Initialize();
  52. }
  53.  
  54. void CRemoteAccessServiceAuthenticationMessageBlock::m_Initialize( void )
  55. {
  56.    ::ZeroMemory( (RASAMB *) this, sizeof( RASAMB ) );
  57.    dwSize = sizeof( RASAMB );
  58. }
  59.  
  60. void CRemoteAccessServiceAuthenticationMessageBlock::Copy( const RASAMB *source )
  61. {
  62.    ASSERT( source != NULL );
  63.  
  64.    if ( source == NULL )
  65.    {
  66.       m_Initialize();
  67.       return;
  68.    }
  69.  
  70.    dwError = source->dwError;
  71.    bLana   = source->bLana;
  72.    ::strcpy( szNetBiosError, source->szNetBiosError );
  73. }
  74.  
  75. void CRemoteAccessServiceAuthenticationMessageBlock::Copy( const CRemoteAccessServiceAuthenticationMessageBlock& source )
  76. {
  77.    dwError = source.dwError;
  78.    bLana   = source.bLana;
  79.    ::strcpy( szNetBiosError, source.szNetBiosError );
  80. }
  81.  
  82. BYTE CRemoteAccessServiceAuthenticationMessageBlock::GetLana( void ) const
  83. {
  84.    return( bLana );
  85. }
  86.  
  87. DWORD CRemoteAccessServiceAuthenticationMessageBlock::GetErrorCode( void ) const
  88. {
  89.    return( dwError );
  90. }
  91.  
  92. void CRemoteAccessServiceAuthenticationMessageBlock::GetErrorString( CString &return_string ) const
  93. {
  94.    return_string = szNetBiosError;
  95. }
  96.  
  97. /*
  98. ** CRemoteAccessServiceNetBEUIFramer
  99. */
  100.  
  101. CRemoteAccessServiceNetBEUIFramer::CRemoteAccessServiceNetBEUIFramer()
  102. {
  103.    m_Initialize();
  104. }
  105.  
  106. CRemoteAccessServiceNetBEUIFramer::CRemoteAccessServiceNetBEUIFramer( const RASPPPNBF *source )
  107. {
  108.    m_Initialize();
  109.    Copy( source );
  110. }
  111.  
  112. CRemoteAccessServiceNetBEUIFramer::CRemoteAccessServiceNetBEUIFramer( const CRemoteAccessServiceNetBEUIFramer& source )
  113. {
  114.    m_Initialize();
  115.    Copy( source );
  116. }
  117.  
  118. CRemoteAccessServiceNetBEUIFramer::~CRemoteAccessServiceNetBEUIFramer()
  119. {
  120.    m_Initialize();
  121. }
  122.  
  123. void CRemoteAccessServiceNetBEUIFramer::m_Initialize( void )
  124. {
  125.    ::ZeroMemory( (RASPPPNBF *) this, sizeof( RASPPPNBF ) );
  126.    dwSize = sizeof( RASPPPNBF );
  127. }
  128.  
  129. void CRemoteAccessServiceNetBEUIFramer::Copy( const RASPPPNBF *source )
  130. {
  131.    ASSERT( source != NULL );
  132.  
  133.    if ( source == NULL )
  134.    {
  135.       m_Initialize();
  136.       return;
  137.    }
  138.  
  139.    dwError        = source->dwError;
  140.    dwNetBiosError = source->dwNetBiosError;
  141.    bLana          = source->bLana;
  142.    ::strcpy( szNetBiosError,    source->szNetBiosError    );
  143.    ::strcpy( szWorkstationName, source->szWorkstationName );
  144. }
  145.  
  146. void CRemoteAccessServiceNetBEUIFramer::Copy( const CRemoteAccessServiceNetBEUIFramer& source )
  147. {
  148.    dwError        = source.dwError;
  149.    dwNetBiosError = source.dwNetBiosError;
  150.    bLana          = source.bLana;                      
  151.    ::strcpy( szNetBiosError,    source.szNetBiosError    );
  152.    ::strcpy( szWorkstationName, source.szWorkstationName );
  153. }
  154.  
  155. BYTE CRemoteAccessServiceNetBEUIFramer::GetLana( void ) const
  156. {
  157.    return( bLana );
  158. }
  159.  
  160. DWORD CRemoteAccessServiceNetBEUIFramer::GetErrorCode( void ) const
  161. {
  162.    return( dwError );
  163. }
  164.  
  165. DWORD CRemoteAccessServiceNetBEUIFramer::GetNetBiosErrorCode( void ) const
  166. {
  167.    return( dwNetBiosError );
  168. }
  169.  
  170. void CRemoteAccessServiceNetBEUIFramer::GetErrorString( CString& return_string ) const
  171. {
  172.    return_string = szNetBiosError;
  173. }
  174.  
  175. void CRemoteAccessServiceNetBEUIFramer::GetWorkstationName( CString& return_string ) const
  176. {
  177.    return_string = szWorkstationName;
  178. }
  179.  
  180. /*
  181. ** CRemoteAccessServiceInternetworkPacketExchange
  182. */
  183.  
  184. CRemoteAccessServiceInternetworkPacketExchange::CRemoteAccessServiceInternetworkPacketExchange()
  185. {
  186.    m_Initialize();
  187. }
  188.  
  189. CRemoteAccessServiceInternetworkPacketExchange::CRemoteAccessServiceInternetworkPacketExchange( const RASPPPIPX * source )
  190. {
  191.    m_Initialize();
  192.    Copy( source );
  193. }
  194.  
  195. CRemoteAccessServiceInternetworkPacketExchange::CRemoteAccessServiceInternetworkPacketExchange( const CRemoteAccessServiceInternetworkPacketExchange& source )
  196. {
  197.    m_Initialize();
  198.    Copy( source );
  199. }
  200.  
  201. CRemoteAccessServiceInternetworkPacketExchange::~CRemoteAccessServiceInternetworkPacketExchange()
  202. {
  203.    m_Initialize();
  204. }
  205.  
  206. void CRemoteAccessServiceInternetworkPacketExchange::m_Initialize( void )
  207. {
  208.    ::ZeroMemory( (RASPPPIPX *) this, sizeof( RASPPPIPX ) );
  209.    dwSize = sizeof( RASPPPIPX );
  210. }
  211.  
  212. void CRemoteAccessServiceInternetworkPacketExchange::Copy( const RASPPPIPX * source )
  213. {
  214.    ASSERT( source != NULL );
  215.  
  216.    if ( source == NULL )
  217.    {
  218.       m_Initialize();
  219.       return;
  220.    }
  221.  
  222.    dwError = source->dwError;
  223.    ::strcpy( szIpxAddress, source->szIpxAddress );
  224. }
  225.  
  226. void CRemoteAccessServiceInternetworkPacketExchange::Copy( const CRemoteAccessServiceInternetworkPacketExchange& source )
  227. {
  228.    dwError = source.dwError;
  229.    ::strcpy( szIpxAddress, source.szIpxAddress );
  230. }
  231.  
  232. DWORD CRemoteAccessServiceInternetworkPacketExchange::GetErrorCode( void ) const
  233. {
  234.    return( dwError );
  235. }
  236.  
  237. void CRemoteAccessServiceInternetworkPacketExchange::GetIPXAddress( CString& return_string ) const
  238. {
  239.    return_string =szIpxAddress;
  240. }
  241.  
  242. /*
  243. ** CRemoteAccessServiceInternetProtocol
  244. */
  245.  
  246. CRemoteAccessServiceInternetProtocol::CRemoteAccessServiceInternetProtocol()
  247. {
  248.    m_Initialize();
  249. }
  250.  
  251. CRemoteAccessServiceInternetProtocol::CRemoteAccessServiceInternetProtocol( const RASPPPIP * source )
  252. {
  253.    m_Initialize();
  254.    Copy( source );
  255. }
  256.  
  257. CRemoteAccessServiceInternetProtocol::CRemoteAccessServiceInternetProtocol( const CRemoteAccessServiceInternetProtocol& source )
  258. {
  259.    m_Initialize();
  260.    Copy( source );
  261. }
  262.  
  263. CRemoteAccessServiceInternetProtocol::~CRemoteAccessServiceInternetProtocol()
  264. {
  265.    m_Initialize();
  266. }
  267.  
  268. void CRemoteAccessServiceInternetProtocol::m_Initialize( void )
  269. {
  270.    ::ZeroMemory( (RASPPPIP *) this, sizeof( RASPPPIP ) );
  271.    dwSize = sizeof( RASPPPIP );
  272. }
  273.  
  274. void CRemoteAccessServiceInternetProtocol::Copy( const RASPPPIP * source )
  275. {
  276.    ASSERT( source != NULL );
  277.  
  278.    if ( source == NULL )
  279.    {
  280.       m_Initialize();
  281.       return;
  282.    }
  283.  
  284.    dwError = source->dwError;
  285.    ::strcpy( szIpAddress, source->szIpAddress );
  286.  
  287. #if ! defined( WINNT35COMPATIBLE )
  288.  
  289.    ::strcpy( szServerIpAddress, source->szServerIpAddress );
  290.  
  291. #endif // WINNT35COMPATIBLE
  292. }
  293.  
  294. void CRemoteAccessServiceInternetProtocol::Copy( const CRemoteAccessServiceInternetProtocol& source )
  295. {
  296.    dwError = source.dwError;
  297.    ::strcpy( szIpAddress, source.szIpAddress );
  298.  
  299. #if ! defined( WINNT35COMPATIBLE )
  300.  
  301.    ::strcpy( szServerIpAddress, source.szServerIpAddress );
  302.  
  303. #endif // WINNT35COMPATIBLE
  304. }
  305.  
  306. DWORD CRemoteAccessServiceInternetProtocol::GetErrorCode( void ) const
  307. {
  308.    return( dwError );
  309. }
  310.  
  311. void CRemoteAccessServiceInternetProtocol::GetIPAddress( CString& return_string ) const
  312. {
  313.    return_string = szIpAddress;
  314. }
  315.  
  316. #if ! defined( WINNT35COMPATIBLE )
  317.  
  318. void CRemoteAccessServiceInternetProtocol::GetServerIPAddress( CString& return_string ) const
  319. {
  320.    return_string = szServerIpAddress;
  321. }
  322.  
  323. #endif // WINNT35COMPATIBLE
  324.  
  325. /*
  326. ** CRemoteAccessService
  327. */
  328.  
  329. CRemoteAccessService::CRemoteAccessService()
  330. {
  331.    m_Initialize();
  332.    m_AutomaticallyClose = FALSE;
  333. }
  334.  
  335. CRemoteAccessService::~CRemoteAccessService()
  336. {
  337.    if ( m_AutomaticallyClose != FALSE )
  338.    {
  339.       Close();
  340.    }
  341.  
  342.    m_Initialize();
  343. }
  344.  
  345. BOOL CRemoteAccessService::Close( LPCTSTR name_of_connection )
  346. {
  347.    ASSERT_VALID( this );
  348.    return( HangUp( name_of_connection ) );
  349. }
  350.  
  351. BOOL CRemoteAccessService::Dial( LPCTSTR who_to_dial )
  352. {
  353.    ASSERT_VALID( this );
  354.    ASSERT( who_to_dial != NULL );
  355.  
  356.    if ( who_to_dial == NULL )
  357.    {
  358.       m_ErrorCode = ERROR_INVALID_PARAMETER;
  359.       return( FALSE );
  360.    }
  361.  
  362.    RASDIALPARAMS dialing_parameters;
  363.  
  364.    ::ZeroMemory( &dialing_parameters, sizeof( dialing_parameters ) );
  365.  
  366.    dialing_parameters.dwSize = sizeof( dialing_parameters );
  367.    ::strcpy( dialing_parameters.szEntryName, who_to_dial );
  368.  
  369.    m_ConnectionHandle = NULL;
  370.  
  371.    m_ErrorCode = ::RasDial( &m_DialExtensions,
  372.                              NULL,
  373.                             &dialing_parameters,
  374.                              1,
  375.                              m_ConnectionCallbackFunctionPointer,
  376.                             &m_ConnectionHandle );
  377.  
  378.    if ( m_ErrorCode == 0 )
  379.    {
  380.       return( TRUE );
  381.    }
  382.    else
  383.    {
  384.       return( FALSE );
  385.    }
  386. }
  387.  
  388. HRASCONN CRemoteAccessService::GetConnection( LPCTSTR name_of_connection )
  389. {
  390.    ASSERT_VALID( this );
  391.  
  392.    if ( name_of_connection == NULL )
  393.    {
  394.       m_ErrorCode = ERROR_INVALID_PARAMETER;
  395.       return( NULL );
  396.    }
  397.  
  398.    LPRASCONN connections       = NULL;
  399.    DWORD     number_of_entries = 0;
  400.  
  401.    m_GetConnectionsIntoMemory( connections, number_of_entries );
  402.  
  403.    HRASCONN return_value = NULL;
  404.  
  405.    if ( m_ErrorCode == 0 )
  406.    {
  407.       DWORD index = 0;
  408.  
  409.       while( index < number_of_entries )
  410.       {
  411.          if ( ::strcmpi( name_of_connection, connections[ index ].szEntryName ) == 0 )
  412.          {
  413.             return_value = connections[ index ].hrasconn;
  414.             index = number_of_entries;
  415.          }
  416.  
  417.          index++;
  418.       }
  419.    }
  420.  
  421.    delete [] connections;
  422.  
  423.    return( return_value );
  424. }
  425.  
  426. BOOL CRemoteAccessService::GetConnections( CStringArray& connection_names )
  427. {
  428.    ASSERT_VALID( this );
  429.  
  430.    connection_names.RemoveAll();
  431.  
  432.    LPRASCONN connections       = NULL;
  433.    DWORD     number_of_entries = 0;
  434.  
  435.    m_GetConnectionsIntoMemory( connections, number_of_entries );
  436.  
  437.    BOOL return_value = FALSE;
  438.  
  439.    if ( m_ErrorCode == 0 )
  440.    {
  441.       return_value = TRUE;
  442.  
  443.       DWORD index = 0;
  444.  
  445.       while( index < number_of_entries )
  446.       {
  447.          connection_names.Add( connections[ index ].szEntryName );
  448.          index++;
  449.       }
  450.    }
  451.  
  452.    delete [] connections;
  453.  
  454.    return( return_value );
  455. }
  456.  
  457. BOOL CRemoteAccessService::GetConnectionStatus( void )
  458. {
  459.    ASSERT_VALID( this );
  460.  
  461.    m_ErrorCode = ::RasGetConnectStatus( m_ConnectionHandle, &m_ConnectionStatus );
  462.  
  463.    if ( m_ErrorCode == 0 )
  464.    {
  465.       return( TRUE );
  466.    }
  467.    else
  468.    {
  469.       return( FALSE );
  470.    }
  471. }
  472.  
  473. BOOL CRemoteAccessService::GetErrorCode( void ) const
  474. {
  475.    ASSERT_VALID( this );
  476.  
  477.    return( m_ErrorCode );
  478. }
  479.  
  480. BOOL CRemoteAccessService::GetErrorString( CString& return_string )
  481. {
  482.    ASSERT_VALID( this );
  483.  
  484.    TCHAR string[ 4096 ];
  485.  
  486.    ::ZeroMemory( string, sizeof( string ) );
  487.  
  488.    if ( ::RasGetErrorString( m_ErrorCode, string, sizeof( string ) ) == 0 )
  489.    {
  490.       return_string = string;
  491.       return( TRUE );
  492.    }
  493.    else
  494.    {
  495.       return_string.Empty();
  496.       return( FALSE );
  497.    }
  498. }
  499.  
  500. BOOL CRemoteAccessService::GetPhoneBookEntries( CStringArray& phone_book_entries )
  501. {
  502.    ASSERT_VALID( this );
  503.  
  504.    phone_book_entries.RemoveAll();
  505.  
  506.    DWORD size_of_buffer         = 64 * sizeof( RASENTRYNAME );
  507.    DWORD number_of_bytes_needed = size_of_buffer;
  508.    DWORD number_of_entries      = 0;
  509.  
  510.    LPRASENTRYNAME memory_buffer = (LPRASENTRYNAME) new BYTE[ size_of_buffer ]; // Get room for 64 entries (to begin with)
  511.  
  512.    if ( memory_buffer == NULL )
  513.    {
  514.       m_ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
  515.       return( FALSE );
  516.    }
  517.  
  518.    ::ZeroMemory( memory_buffer, size_of_buffer );
  519.  
  520.    memory_buffer->dwSize = sizeof( RASENTRYNAME );
  521.  
  522.    m_ErrorCode = ::RasEnumEntries( NULL, NULL, memory_buffer, &number_of_bytes_needed, &number_of_entries );
  523.  
  524.    if ( m_ErrorCode != 0 )
  525.    {
  526.       if ( m_ErrorCode == ERROR_BUFFER_TOO_SMALL || m_ErrorCode == ERROR_NOT_ENOUGH_MEMORY )
  527.       {
  528.          delete [] memory_buffer;
  529.  
  530.          memory_buffer = (LPRASENTRYNAME) new BYTE[ number_of_bytes_needed ];
  531.  
  532.          if ( memory_buffer == NULL )
  533.          {
  534.             m_ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
  535.             return( FALSE );
  536.          }
  537.  
  538.          ::ZeroMemory( memory_buffer, number_of_bytes_needed );
  539.  
  540.          memory_buffer->dwSize = sizeof( RASENTRYNAME );
  541.          m_ErrorCode = ::RasEnumEntries( NULL, NULL, memory_buffer, &number_of_bytes_needed, &number_of_entries );
  542.       }
  543.    }
  544.  
  545.    BOOL return_value = FALSE;
  546.  
  547.    if ( m_ErrorCode == 0 )
  548.    {
  549.       return_value = TRUE;
  550.  
  551.       DWORD index = 0;
  552.  
  553.       while( index < number_of_entries )
  554.       {
  555.          phone_book_entries.Add( memory_buffer[ index ].szEntryName );
  556.          index++;
  557.       }
  558.    }
  559.  
  560.    delete [] memory_buffer;
  561.  
  562.    return( return_value );
  563. }
  564.  
  565. BOOL CRemoteAccessService::GetProtocolInformation( CRemoteAccessServiceAuthenticationMessageBlock& data_to_get )
  566. {
  567.    ASSERT_VALID( this );
  568.  
  569.    CRemoteAccessServiceAuthenticationMessageBlock return_data;
  570.  
  571.    if ( ::RasGetProjectionInfo( m_ConnectionHandle, RASP_Amb, (LPVOID) (RASAMB *) &return_data, &return_data.dwSize ) == 0 )
  572.    {
  573.       data_to_get.Copy( return_data );
  574.  
  575.       return( TRUE );
  576.    }
  577.    else
  578.    {
  579.       return( FALSE );
  580.    }
  581. }
  582.  
  583. BOOL CRemoteAccessService::GetProtocolInformation( CRemoteAccessServiceNetBEUIFramer& data_to_get )
  584. {
  585.    ASSERT_VALID( this );
  586.  
  587.    CRemoteAccessServiceNetBEUIFramer return_data;
  588.  
  589.    if ( ::RasGetProjectionInfo( m_ConnectionHandle, RASP_PppNbf, (LPVOID) (RASPPPNBF *) &return_data, &return_data.dwSize ) == 0 )
  590.    {
  591.       data_to_get.Copy( return_data );
  592.  
  593.       return( TRUE );
  594.    }
  595.    else
  596.    {
  597.       return( FALSE );
  598.    }
  599. }
  600.  
  601. BOOL CRemoteAccessService::GetProtocolInformation( CRemoteAccessServiceInternetworkPacketExchange& data_to_get )
  602. {
  603.    ASSERT_VALID( this );
  604.  
  605.    CRemoteAccessServiceInternetworkPacketExchange return_data;
  606.  
  607.    if ( ::RasGetProjectionInfo( m_ConnectionHandle, RASP_PppIpx, (LPVOID) (RASPPPIPX *) &return_data, &return_data.dwSize ) == 0 )
  608.    {
  609.       data_to_get.Copy( return_data );
  610.  
  611.       return( TRUE );
  612.    }
  613.    else
  614.    {
  615.       return( FALSE );
  616.    }
  617. }
  618.  
  619. BOOL CRemoteAccessService::GetProtocolInformation( CRemoteAccessServiceInternetProtocol& data_to_get )
  620. {
  621.    ASSERT_VALID( this );
  622.  
  623.    CRemoteAccessServiceInternetProtocol return_data;
  624.  
  625.    if ( ::RasGetProjectionInfo( m_ConnectionHandle, RASP_PppIp, (LPVOID) (RASPPPIP *) &return_data, &return_data.dwSize ) == 0 )
  626.    {
  627.       data_to_get.Copy( return_data );
  628.  
  629.       return( TRUE );
  630.    }
  631.    else
  632.    {
  633.       return( FALSE );
  634.    }
  635. }
  636.  
  637. BOOL CRemoteAccessService::HangUp( LPCTSTR name_of_connection )
  638. {
  639.    ASSERT_VALID( this );
  640.  
  641.    if ( name_of_connection == NULL )
  642.    {
  643.       m_ErrorCode = ::RasHangUp( m_ConnectionHandle );
  644.       m_ConnectionHandle = NULL;
  645.    }
  646.    else
  647.    {
  648.       HRASCONN temp_handle = GetConnection( name_of_connection );
  649.       m_ErrorCode = ::RasHangUp( temp_handle );
  650.    }
  651.  
  652.    if ( m_ErrorCode == 0 )
  653.    {
  654.       return( TRUE );
  655.    }
  656.    else
  657.    {
  658.       return( FALSE );
  659.    }
  660. }
  661.  
  662. BOOL CRemoteAccessService::IsConnected( void )
  663. {
  664.    ASSERT_VALID( this );
  665.  
  666.    GetConnectionStatus();
  667.  
  668.    if ( m_ConnectionStatus.rasconnstate == RASCS_Connected )
  669.    {
  670.       return( TRUE );
  671.    }
  672.    else
  673.    {
  674.       return( FALSE );
  675.    }
  676. }
  677.                                                               
  678. void CRemoteAccessService::m_GetConnectionsIntoMemory( LPRASCONN& connections, DWORD& number_of_connections )
  679. {
  680.    ASSERT_VALID( this );
  681.  
  682.    DWORD size_of_buffer         = 64 * sizeof( RASCONN );
  683.    DWORD number_of_bytes_needed = size_of_buffer;
  684.    DWORD number_of_entries      = 0;
  685.  
  686.    LPRASCONN memory_buffer = (LPRASCONN) new BYTE[ size_of_buffer ]; // Get room for 64 entries (to begin with)
  687.  
  688.    if ( memory_buffer == NULL )
  689.    {
  690.       m_ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
  691.       return;
  692.    }
  693.  
  694.    ::ZeroMemory( memory_buffer, size_of_buffer );
  695.  
  696.    memory_buffer->dwSize = sizeof( RASCONN );
  697.  
  698.    m_ErrorCode = ::RasEnumConnections( memory_buffer, &number_of_bytes_needed, &number_of_entries );
  699.  
  700.    if ( m_ErrorCode != 0 )
  701.    {
  702.       if ( m_ErrorCode == ERROR_BUFFER_TOO_SMALL || m_ErrorCode == ERROR_NOT_ENOUGH_MEMORY )
  703.       {
  704.          delete [] memory_buffer;
  705.  
  706.          memory_buffer = (LPRASCONN) new BYTE[ number_of_bytes_needed ];
  707.  
  708.          if ( memory_buffer == NULL )
  709.          {
  710.             m_ErrorCode = ERROR_NOT_ENOUGH_MEMORY;
  711.             return;
  712.          }
  713.  
  714.          ::ZeroMemory( memory_buffer, number_of_bytes_needed );
  715.  
  716.          memory_buffer->dwSize = sizeof( RASCONN );
  717.          m_ErrorCode = ::RasEnumConnections( memory_buffer, &number_of_bytes_needed, &number_of_entries );
  718.       }
  719.    }
  720.  
  721.    connections           = memory_buffer;
  722.    number_of_connections = number_of_entries;
  723. }
  724.  
  725. void CRemoteAccessService::m_Initialize( void )
  726. {
  727.    ASSERT_VALID( this );
  728.  
  729.    ::ZeroMemory( &m_ConnectionStatus, sizeof( m_ConnectionStatus ) );
  730.    m_ConnectionStatus.dwSize = sizeof( m_ConnectionStatus );
  731.  
  732.    ::ZeroMemory( &m_DialExtensions, sizeof( m_DialExtensions ) );
  733.    m_DialExtensions.dwSize = sizeof( m_DialExtensions );
  734.  
  735.    m_ErrorCode        = 0;
  736.    m_ConnectionHandle = NULL;
  737.    m_ConnectionCallbackFunctionPointer = NULL;
  738. }
  739.  
  740. BOOL CRemoteAccessService::Open( LPCTSTR what_to_open )
  741. {
  742.    ASSERT_VALID( this );
  743.  
  744.    return( Dial( what_to_open ) );
  745. }
  746.  
  747. BOOL CRemoteAccessService::SetAutomaticallyClose( BOOL auto_close )
  748. {
  749.    BOOL return_value = m_AutomaticallyClose;
  750.  
  751.    m_AutomaticallyClose = auto_close;
  752.  
  753.    return( return_value );
  754. }
  755.  
  756. LPVOID CRemoteAccessService::SetConnectionCallback( LPVOID function_pointer )
  757. {
  758.    LPVOID return_value = m_ConnectionCallbackFunctionPointer;
  759.  
  760.    m_ConnectionCallbackFunctionPointer = function_pointer;
  761.  
  762.    return( return_value );
  763. }
  764.  
  765. DWORD CRemoteAccessService::SetDialOptions( DWORD dial_options )
  766. {
  767.    DWORD return_value = m_DialExtensions.dwfOptions;
  768.  
  769.    m_DialExtensions.dwfOptions = dial_options;
  770.  
  771.    return( return_value );
  772. }
  773.